package Flightadministration;

import Data.*;
import DB.*;
import Report.*;
import java.rmi.RemoteException;
import java.util.Date;
import java.util.Vector;

/**
 *
 * @author Fabian Hoh
 * @author Philipp Armbruster
 *
 */

public class FlightadministrationImpl extends java.rmi.server.UnicastRemoteObject implements Flightadministration {

    /**
     *
     * Variablen der Klassen des data-Packages
     *
     */

        /**
         * Variable der Klasse Aircraft (Flugzeug), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Aircraft currentAircraft = null;

        /**
         * Variable der Klasse Airline (Fluglinie), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Airline currentAirline = null;

        /**
         * Variable der Klasse Airport (Flughafen), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Airport currentAirport = null;

        /**
         * Variable der Klasse Booking (Buchung), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Booking currentBooking = null;

        /**
         * Variable der Klasse Flight (Flug), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Flight currentFlight = null;

        /**
         * Variable der Klasse FlightRealization (Flugdurchführung), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private FlightRealization currentFlightRealization = null;

        /**
         * Variable der Klasse Passenger (Passagier), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Passenger currentPassenger = null;

        /**
         * Variable der Klasse Seat (Sitzstruktur), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private Seat currentSeat = null;

        /**
         * Variable der Klasse TypeOfAircraft (Flugzeugtyp), in die über set-/get-Methoden das aktuelle Objekt zwischengespeichert werden kann
         */
        private TypeOfAircraft currentTypeOfAircraft = null;

    /**
     *
     * Objekte der einzelnen Mapperklassen
     *
     */

        /**
         * AirportMapper Objekt
         */
        private AirportMapper airportMapper = AirportMapper.getInstance();
        /**
         * AirlineMapper Objekt
         */
        private AirlineMapper airlineMapper = AirlineMapper.getInstance();
        /**
         * AircraftMapper Objekt
         */
        private AircraftMapper aircraftMapper = AircraftMapper.getInstance();
        /**
         * TypeOfAircraftMapper Objekt
         */
        private TypeOfAircraftMapper typeOfAircraftMapper = TypeOfAircraftMapper.getInstance();
        /**
         * FlightMapper Objekt
         */
        private FlightMapper flightMapper = FlightMapper.getInstance();
        /**
         * FlightRealizationMapper Objekt
         */
        private FlightRealizationMapper flightRealizationMapper = FlightRealizationMapper.getInstance();
        /**
         * PassengerMapper Objekt
         */
        private PassengerMapper passengerMapper = PassengerMapper.getInstance();
        /**
         * SeatMapper Objekt
         */
        private SeatMapper seatMapper = SeatMapper.getInstance();
        /**
         * BookingMapper Objekt
         */
        private BookingMapper bookingMapper = BookingMapper.getInstance();

        
    /**
     * 
     * Referenz auf den ReportGenerator
     * 
     */
    private ReportGenerator reportGenerator = null;

    

    FlightadministrationImpl(AirportMapper airportMapper, AirlineMapper airlineMapper,
            AircraftMapper aircraftMapper, TypeOfAircraftMapper typeOfAircraftMapper,
            FlightMapper flightMapper, FlightRealizationMapper flightRealizationMapper,
            PassengerMapper passengerMapper, SeatMapper seatMapper, BookingMapper bookingMapper) throws java.rmi.RemoteException {

        this.airportMapper = airportMapper;
        this.airlineMapper = airlineMapper;
        this.aircraftMapper = aircraftMapper;
        this.typeOfAircraftMapper = typeOfAircraftMapper;
        this.bookingMapper = bookingMapper;
        this.flightMapper = flightMapper;
        this.flightRealizationMapper = flightRealizationMapper;
        this.passengerMapper = passengerMapper;
        this.seatMapper = seatMapper;
    }

    public FlightadministrationImpl() throws RemoteException {
    }


    /*      -       Create-Methoden     -       */

    
    /**
     * Einen Flughafen anlegen
     *
     * @param internationalId
     * @param portName
     * @param portCity
     * @param portCountry
     * @return Ein Flughafen
     * @throws java.rmi.RemoteException
     */
    @Override
    public Airport createAirport(String internationalId, String portName,
            String portCity, String portCountry) throws java.rmi.RemoteException {

        Airport ap = new AirportImpl(internationalId, portName, portCity, portCountry);

        return this.airportMapper.insert(ap);
    }

    /**
     * Eine Fluglinie anlegen
     *
     * @param airName
     * @return Eine Fluglinie
     * @throws java.rmi.RemoteException
     */
    public Airline createAirline(String airName) throws java.rmi.RemoteException {

        Airline al = new AirlineImpl(airName);

        return this.airlineMapper.insert(al);
    }

    /**
     * Ein Flugzeug anlegen
     *
     * @param craftName
     * @param airlineId
     * @param typeOfAircraftId 
     * @return Ein Flugzeug
     * @throws java.rmi.RemoteException
     */
    public Aircraft createAircraft(String craftName, int airlineId, int typeOfAircraftId)
            throws java.rmi.RemoteException {

        Aircraft ac = new AircraftImpl(craftName, airlineId, typeOfAircraftId);

        return this.aircraftMapper.insert(ac);
    }

    /**
     * Einen Flugzeugtyp anlegen
     *
     * @param craftTypeName
     * @param seatArea
     * @return Ein Flugzeugtyp
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft createTypeOfAircraft(String craftTypeName, int seatId)
            throws java.rmi.RemoteException {

        TypeOfAircraft tOA = new TypeOfAircraftImpl(craftTypeName, seatId);

        return this.typeOfAircraftMapper.insert(tOA);
    }

    /**
     * Einen Flug anlegen
     *
     * @param timeOfDeparture
     * @param dayOfDeparture
     * @param timeOfArrival
     * @param dayOfArrival
     * @param departureAirportId
     * @param arrivalAirportId
     * @param airlineId
     * @return Geplanten Flug anlegen
     * @throws java.rmi.RemoteException
     */
    public Flight createFlight(String timeOfDeparture, String dayOfDeparture,
            String timeOfArrival, String dayOfArrival, String departureAirportId,
            String arrivalAirportId, int airlineId) throws java.rmi.RemoteException {

        Flight f = new FlightImpl(timeOfDeparture, dayOfDeparture, timeOfArrival,
                dayOfArrival, departureAirportId, arrivalAirportId, airlineId);

        return this.flightMapper.insert(f);
    }

    /**
     * Eine Flugdurchführung anlegen
     *
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param flightId
     * @param aircraftId
     * @return Eine Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public FlightRealization createFlightRealization(Date dateOfDeparture,
            Date dateOfArrival, int flightId, int aircraftId) throws java.rmi.RemoteException {

        FlightRealization fr = new FlightRealizationImpl(dateOfDeparture, dateOfArrival, flightId, aircraftId);

        return this.flightRealizationMapper.insert(fr);
    }

    /**
     * Einen Passagier anlegen
     *
     * @param firstName
     * @param lastName
     * @param street
     * @param postcode
     * @param city
     * @return Ein Passagier
     * @throws java.rmi.RemoteException
     */
    public Passenger createPassenger(String firstName, String lastName,
            String street, int postcode, String city) throws java.rmi.RemoteException {

        Passenger p = new PassengerImpl(firstName, lastName, street, postcode, city);

        return this.passengerMapper.insert(p);
    }

    /**
     * Eine Sitzstrukturn anlegen
     *
     * @param seatsPerRow
     * @param numberOfRows
     * @return Eine Sitzstruktur
     * @throws java.rmi.RemoteException
     */
    public Seat createSeat(int seatsPerRow, int numberOfRows) throws java.rmi.RemoteException {

        Seat s = new SeatImpl(seatsPerRow, numberOfRows);

        return this.seatMapper.insert(s);
    }

    /**
     * Eine Buchung anlegen
     *
     * @param passengerId
     * @param realizationId
     * @return Eine Buchung
     * @throws java.rmi.RemoteException
     */
    public Booking createBooking(int passengerId, int realizationId)
            throws java.rmi.RemoteException {

        Booking b = new BookingImpl(passengerId, realizationId);

        return this.bookingMapper.insert(b);
    }

    /**
     * Einen Dauerauftrag für einen bestimmten Flug anlegen
     *
     * @param StartOfStandingOrder
     * @param EndOfStandingOrder
     * @param passengerId
     * @param realizationId
     * @return Eine / mehrere Buchungen
     * @throws java.rmi.RemoteException
     */
    public Vector<Booking> createStandingOrderForBookings(Date startOfStandingOrder, Date endOfStandingOrder, int passengerId, int realizationId)
            throws java.rmi.RemoteException {

        /* FlightId der betroffenen realizationId auslesen um damit die zusätzlichen FlightRealizations anzulegen */
        int flightId = this.flightRealizationMapper.findFlightIdByRealizationId(realizationId);

        /* AircraftId der betroffenen realizationId auslesen um damit die zusätzlichen FlightRealizations anzulegen */
        int aircraftId = this.flightRealizationMapper.findAircraftIdByRealizationId(realizationId);
        
        /* Dateobjekt aus Abflugdatum der ausgewählten FlightRealization erstellen und
         * daraus den Wochentag als String auslesen */
        Date dateOfChosenFlightRealization = this.flightRealizationMapper.findById(realizationId).getDateOfDeparture();

        /* Longwert bestimmt den Zeitraum bis zur nächsten FlightRealization, 
         * in diesem Fall errechnet er die Millisecounds für das Datum in 7 Tagen */
        long oneWeek = 7 * 24 * 60 * 60 * 1000;
        /* Das Datum der nächsten FlightRealization */
        Date dateForNextFlightRealization = new Date(dateOfChosenFlightRealization.getTime() + oneWeek);


        /* Vector erzeugen und diesem alle (nicht nur einer FlightId) FlightRealizations im betroffenen Zeitraum des Dauerauftrages
         * (zwi. Start- und Enddatum) zuweisen. */
        Vector<FlightRealization> allFlightRealizationsInTimeframe = this.flightRealizationMapper.findAllFlightRealizationsByTimeframe(startOfStandingOrder, endOfStandingOrder);

        /* Vector erzeugen, dem in der nachfolgenden for-Schleife alle FlightRealizations der entsprechenden FlightId und
         * im entsprechenden Zeitraum zugewiesen werden */
        Vector<FlightRealization> allFlightRealizationsOfRequestedFlightInTimeframe = new Vector<FlightRealization>();

        for(int i = 0; i<allFlightRealizationsInTimeframe.size(); i++) {
            if(allFlightRealizationsInTimeframe.get(i).getRelatedFlightId() == flightId) {
                allFlightRealizationsOfRequestedFlightInTimeframe.add(allFlightRealizationsInTimeframe.get(i));
            }
        }

        /* Vector erzeugen, dem in der nachfolgenden for-Schleife alle Abflugdaten (Dateobjekt) der betroffenen FlightRealizations
         * gespeichert werden um vor dem Erstellen einer neuen FlightRealization zu überprüfen, ob an diesem Datum nicht
         * bereits eine FlightRealization vorhanden ist */
        Vector<Date> datesOfAllFlightRealizationsOfRequestedFlightInTimeframe = new Vector<Date>();

        for(int i = 0; i<allFlightRealizationsOfRequestedFlightInTimeframe.size(); i++) {
            Date TempDate = allFlightRealizationsOfRequestedFlightInTimeframe.get(i).getDateOfDeparture();
            datesOfAllFlightRealizationsOfRequestedFlightInTimeframe.add(TempDate);
        }

        /* Neue FlightRealizations bis zum Ende des Auftragszeitraums anlegen */
        while(dateOfChosenFlightRealization.before(endOfStandingOrder)) {
            while(dateForNextFlightRealization.before(endOfStandingOrder)) {
                /* Prüfen ob für das Datum, für das die nächste FlightRealization angelegt werden soll, nicht bereits eine
                 * FlightRealization vorhanden ist */
                if(datesOfAllFlightRealizationsOfRequestedFlightInTimeframe.contains(dateForNextFlightRealization)) {
                    /* Ist an diesem Datum bereits eine vorhanden, wird nur das Datum um eine Woche erhöht */
                    Date d = new Date(dateForNextFlightRealization.getTime() + oneWeek);
                    dateForNextFlightRealization = d;
                }
                else {
                    /* Ist an diesem Datum keine FlightRealization vorhanden, wird eine Neue angelegt. */
                    Date dateOfFlightRealization = dateForNextFlightRealization;

                    FlightRealization fr = new FlightRealizationImpl(dateOfFlightRealization, dateOfFlightRealization, flightId, aircraftId);
                    /* FlightRealization wird in die Datenbank gespeichert */
                    this.flightRealizationMapper.insert(fr);
                    /* Die angelegte FlightRealization wird in den Vector gespeichert der alle FlightRealization im betroffenen
                     * Zeitraum enthält, da im späteren Verlauf Buchungen für alle FlightRealizations in diesem Vector erzeugt werden. */
                    allFlightRealizationsOfRequestedFlightInTimeframe.add(fr);
                    /* Das Datum für die nächste FlightRealization wird um eine Woche erhöht */
                    Date d = new Date(dateForNextFlightRealization.getTime() + oneWeek);
                    dateForNextFlightRealization = d;
                }
            }
            break;
        }

        /* Vector erzeugen, in den alle in der darauffolgenden for-Schleife durchgeführten Bookings gespeichert werden.
         * Nach Abschluss aller Bookings des Dauerauftrages werden diese gesammelt zurückgegeben */
        Vector<Booking> bookings = new Vector<Booking>();

        for(int i = 0; i<allFlightRealizationsOfRequestedFlightInTimeframe.size(); i++) {

            /* RealizationId der aktuell ausgewählten FlightRealization auslesen um daraufhin eine Booking anzulegen */
            int realId = allFlightRealizationsOfRequestedFlightInTimeframe.get(i).getRealizationId();
            Booking b = new BookingImpl(passengerId, realId);
            /* Booking sowohl in die Datenbank speichern als auch in den Vector mit allen Bookings dieses Dauerauftrages */
            this.bookingMapper.insert(b);
            bookings.add(b);
        }
                
        return bookings;
    }

    /**
     * CheckIn der entsprechenden Buchung durchführen und dabei dem Passagier einen festen Sitzplatz zuweisen.
     *
     * @param bookingId
     * @return date (Datum des CheckIn), seat (Sitzplatz)
     * @throws java.rmi.RemoteException
     */
    public void checkIn(int bookingId, int realizationId) throws java.rmi.RemoteException {

        /* Anzahl der Reihen (numberOfRows) und die Anzahl der Plätze pro Reihe (seatsPerRow)
         * des Flugzeuges, mit dem der Flug durchgeführt wird.
         * Diese beiden Variablen werden benötigt um die Größe der Matrix zu bestimmen.
         */
        int numberOfRows = this.flightRealizationMapper.getNumberOfRows(realizationId);
        int seatsPerRow = this.flightRealizationMapper.getNumberOfSeatsPerRow(realizationId);

        /* pointerSpR zeigt auf den nächsten freien Sitzplatz innerhalb der aktuellen Reihe
         * auf die der pointerR zeigt. */
        int pointerSpR = this.flightRealizationMapper.getPointerSpR(realizationId);
        int pointerR = this.flightRealizationMapper.getPointerR(realizationId);

        /* Array das die Buchstaben (characters) enthält, um die Sitzplätze pro Reihe zu bezeichnen */
        char[] abc = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};

        /* Der Variable seat (Sitzplatz) wird am Ende der Methode der Sitzplatz übergeben
         * der anschließend in die Datenbank gespeichert. */
        String seatPosition;

        /* Matrix für die Sitzplatzbelegung wird erzeugt. Als Grundlage für die Festlegung der Größe
         * dienen die oben deklarierten Variablen numberOfRows und seatsPerRow */
        int[][] checkIns = new int[numberOfRows][seatsPerRow];

        /* Ein Dateobjekt wird erzeugt um am Ende der Methode einen Timestamp, als Beweis für den
         * CheckIn, ausgeben zu können. */
        Date date = new Date();

        if(pointerSpR == seatsPerRow) {

            /* Wenn ja, wird eine Reihe weiter... */
            ++pointerR;
            /* ... an deren Anfang gegangen. */
            pointerSpR = 0;

            /* Die Buchungsnummer wird dem nächsten freien Sitzplatz im Flugzeug zugewiesen */
            checkIns[pointerR][pointerSpR] = bookingId;

            /* Der Sitzplatz wird als String ausgelesen */
            int valueOfRowFromPointerR = pointerR;
            int valueOfRowAsInt = valueOfRowFromPointerR + 1;
            String valueOfRowAsString = String.valueOf(valueOfRowAsInt);
            String seatInRowAsString = String.valueOf(abc[pointerSpR]);
            seatPosition = valueOfRowAsString + seatInRowAsString;

            /* Der Zähler, der auf den nächsten freien Sitzplatz innerhalb einer Reihe zeigt, wird um 1 erhöht. */
            pointerSpR++;
        }
        else {
            /* Wenn die aktuelle Reihe noch nicht voll ist,
             * wird die Buchungsnummer dem nächsten freien Sitzplatz im Flugzeug zugewiesen */
            checkIns[pointerR][pointerSpR] = bookingId;

            /* Der Sitzplatz wird als String ausgelesen */
            int valueOfRowFromPointerR = pointerR;
            int valueOfRowAsInt = valueOfRowFromPointerR + 1;
            String valueOfRowAsString = String.valueOf(valueOfRowAsInt);
            String seatInRowAsString = String.valueOf(abc[pointerSpR]);
            seatPosition = valueOfRowAsString + seatInRowAsString;

            /* Der Zähler, der auf den nächsten freien Sitzplatz innerhalb einer Reihe zeigt, wird um 1 erhöht. */
            pointerSpR++;
        }
        
        /* Das betroffene Booking Objekt aus der Datenbank holen  */
        Booking b = this.bookingMapper.findById(bookingId);
        /* Bookingobjekt den Sitzplatz sowie das CheckIndatum zuweisen, da diese attribute noch nicht zugewiesen wurden. */
        b.setSeatPosition(seatPosition);
        b.setCheckInDate(date);
        /* Methode in Mapperklasse ausrufen die die Werte in die Datenbank speichert */
        this.bookingMapper.executeCheckInForSpecificBooking(b);

        /* Aktualisierte Pointerwerte in die Datenbank speichern */
        this.flightRealizationMapper.setPointerR(realizationId, pointerR);
        this.flightRealizationMapper.setPointerSpR(realizationId, pointerSpR);
    }


    /*      -       Update-Methoden     -       */


    /**
     * Die Eigenschaften eines Flughafens ändern
     *
     * @param internationalId
     * @param portName
     * @param portCity
     * @param portCountry
     * @throws java.rmi.RemoteException
     */
    public void updateAirport(String internationalId, String portName, String portCity, String portCountry) throws java.rmi.RemoteException {

        Airport a = new AirportImpl(internationalId, portName, portCity, portCountry);
        a.setInternationalId(internationalId);

        this.airportMapper.update(a);
    }

    /**
     * Die Eigenschaften einer Airline ändern
     *
     * @param airId
     * @param airName
     * @throws java.rmi.RemoteException
     */
    public void updateAirline(int airId, String airName) throws java.rmi.RemoteException {

        Airline a = new AirlineImpl(airName);
        a.setAirId(airId);

        this.airlineMapper.update(a);
    }

    /**
     * Die Eigenschaften eines Flugzeuges ändern
     *
     * @param craftId
     * @param craftName
     * @param airlineId
     * @param typeOfAircraftId
     * @throws java.rmi.RemoteException
     */
    public void updateAircraft(int craftId, String craftName, int airlineId, int typeOfAircraftId) throws java.rmi.RemoteException {

        Aircraft a = new AircraftImpl(craftName, airlineId, typeOfAircraftId);
        a.setCraftId(craftId);
        
        this.aircraftMapper.update(a);
    }

    /**
     * Die Eigenschaften eines Flugzeugtyps ändern
     *
     * @param craftTypeId
     * @param craftTypeName
     * @param seatId
     * @throws java.rmi.RemoteException
     */
    public void updateTypeOfAircraft(int craftTypeId, String craftTypeName, int seatId) throws java.rmi.RemoteException {

        TypeOfAircraft tOA = new TypeOfAircraftImpl(craftTypeName, seatId);
        tOA.setCraftTypeId(craftTypeId);

        this.typeOfAircraftMapper.update(tOA);
    }

    /**
     * Die Eigenschaften eines geplanten Fluges ändern
     *
     * @param flightId
     * @param timeOfDeparture
     * @param dayOfDeparture
     * @param timeOfArrival
     * @param dayOfArrival
     * @param departureAirportId
     * @param arrivalAirportId
     * @param airlineId
     * @throws java.rmi.RemoteException
     */
    public void updateFlight(int flightId, String timeOfDeparture, String dayOfDeparture,
            String timeOfArrival, String dayOfArrival, String departureAirportId, String arrivalAirportId, int airlineId)
                throws java.rmi.RemoteException {

        Flight f = new FlightImpl(timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival,
                                  departureAirportId, arrivalAirportId, airlineId);
        f.setFlightId(flightId);

        this.flightMapper.update(f);
    }

    /**
     * Die Eigenschaften eines vor der Durchführung stehenden Fluges ändern
     *
     * @param realizationId
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param flightId
     * @param aircraftId
     * @throws java.rmi.RemoteException
     */
    public void updateFlightRealization(int realizationId, Date dateOfDeparture, Date dateOfArrival, int flightId, int aircraftId)
            throws java.rmi.RemoteException {

        FlightRealization fR = new FlightRealizationImpl(dateOfDeparture, dateOfArrival, flightId, aircraftId);
        fR.setRealizationId(realizationId);

        this.flightRealizationMapper.update(fR);
    }

    /**
     * Die Eigenschaften eines Passagiers ändern
     *
     * @param passengerId
     * @param firstName
     * @param lastName
     * @param street
     * @param postcode
     * @param city
     * @throws java.rmi.RemoteException
     */
    public void updatePassenger(int passengerId, String firstName, String lastName, String street, int postcode, String city)
            throws java.rmi.RemoteException {

        Passenger p = new PassengerImpl(firstName, lastName, street, postcode, city);
        p.setPassengerId(passengerId);

        this.passengerMapper.update(p);
    }

    /**
     * Die Eigenschaften einer Sitzstruktur ändern
     *
     * @param seatId
     * @param seatsPerRow
     * @param numberOfRows
     * @throws java.rmi.RemoteException
     */
    public void updateSeat(int seatId, int seatsPerRow, int numberOfRows) throws java.rmi.RemoteException {

        // Gesamtsitzplatzanzahl neu berechnen
        int numberOfAllSeats = seatsPerRow * numberOfRows;

        Seat s = new SeatImpl(seatsPerRow, numberOfRows);
        s.setSeatId(seatId);
        s.setNumberOfAllSeats(numberOfAllSeats);
        
        this.seatMapper.update(s);
    }

    /**
     * Die Eigenschaften einer Buchung ändern
     *
     * @param bookingId
     * @param passengerId
     * @param realizationId
     * @throws java.rmi.RemoteException
     */
    public void updateBooking(int bookingId, int passengerId, int realizationId) throws java.rmi.RemoteException {

        Booking b = new BookingImpl(passengerId, realizationId);
        b.setBookingId(bookingId);

        this.bookingMapper.update(b);
    }

    
    /*      -       Delete-Methoden     -       */


    /**
     * Löscht den ausgewählten Flughafen in der Datenbank
     *
     * @param internationalId
     * @param portName
     * @param portCity
     * @param portCountry
     * @throws java.rmi.RemoteException
     */
    public void deleteAirport(String internationalId, String portName, String portCity, String portCountry) throws java.rmi.RemoteException {

        // Das Airportobjekt wird aus den übergebenen Attributen gebildet
        Airport a = new AirportImpl(internationalId, portName, portCity, portCountry);

        // Vector, der durch das Löschen des Airports alle betroffenen Flights festhält, um später alle betroffenen FlightRealizations zu finden bzw. zu löschen
        Vector<Flight> allRelatedFlights = this.flightMapper.findAllFlightsAssociatedWithAirport(internationalId);

        // Vector, der alle betroffenen FlightRealizations festhält. Sobald der Flight aus dem oben erstellten Vector in einer FlightRealization vorkommt, wird diese in den Vector geschrieben.
        Vector<FlightRealization> allRelatedFlightRealizations = new Vector<FlightRealization>();

        // Für jeden betroffenen Flight, werden die assoziierten FlightRealizations gesucht
        for(int i=0; i<allRelatedFlights.size(); i++){
            // Methode, die für den jeweiligen Flug die betroffenen FlightRealizations findet
            Vector<FlightRealization> allFlightRsForSpecificFlight = this.flightRealizationMapper.findAllFlightRAssociatedWithFlightId(allRelatedFlights.get(i).getFlightId());

            // Alle FlightRealizations, die den speziellen Flug inne haben, werden an die nächste freie Stelle des Ergebnisvector angefügt.
            allRelatedFlightRealizations.addAll(allFlightRsForSpecificFlight);
        }

        // Alle Bookings, die eine betroffene FlightRealization beinhalten, werden gelöscht
        for(int i=0; i<allRelatedFlightRealizations.size();i++){
            this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(allRelatedFlightRealizations.get(i).getRealizationId());
        }

        // Jetzt erst erfolgt das Löschen der Flights mit dem assoziierten Airport. Dabei ist egal, ob der Airport Abflughafen oder Ankunftshafen ist
        this.flightMapper.deleteAllFlightsWithAirportId(internationalId);

        // Zudem werden alle FlightRealizations gelöscht, die einem nicht mehr existierenden Flight zugeordnet sind
        for(int i=0; i<allRelatedFlights.size(); i++){
            this.flightRealizationMapper.deleteAllFlightRWithAssociatedFlightId(allRelatedFlights.get(i).getFlightId());
        }

        // Der betroffene Airport muss noch gelöscht werden
        this.airportMapper.delete(a);

    }

    /**
     * Löscht die ausgewählte Airline in der Datenbank
     *
     * @param airId
     * @param airName
     * @throws java.rmi.RemoteException
     */
    public void deleteAirline(int airId, String airName) throws java.rmi.RemoteException {

        /* Airlineobjekt wird mittels den übergebenen Werten angelegt */
        Airline a = new AirlineImpl(airName);
        a.setAirId(airId);

        /* Vector in den alle Flüge gespeichert werden, die mit der Airline durchgeführt werden sollten die nun gelöscht wird und die daher ebenfalls gelöscht werden */
        Vector<Flight> allRelatedFlights = this.flightMapper.findAllFlightsAssociatedWithAirline(airId);

        /* Vector, der alle betroffenen FlightRealizations beinhaltet */
        Vector<FlightRealization> allRelatedFlightRealizations = new Vector<FlightRealization>();

        /* Bei jedem Flight wird nun nach einer zugehörigen FlightRealization gesucht */
        for(int i=0; i<allRelatedFlights.size(); i++){
            /* Methode, die für den jeweiligen Flug die betroffenen FlightRealizations findet */
            Vector<FlightRealization> allFlightRsForSpecificFlight = this.flightRealizationMapper.findAllFlightRAssociatedWithFlightId(allRelatedFlights.get(i).getFlightId());

            /* Alle FlightRealizations, die den speziellen Flug inne haben, werden an die nächste freie Stelle des Ergebnisvector angefügt. */
            allRelatedFlightRealizations.addAll(allFlightRsForSpecificFlight);
        }

        /* Alle Bookings, die eine betroffene FlightRealization beinhalten, werden gelöscht */
        for(int i=0; i<allRelatedFlightRealizations.size();i++){
            this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(allRelatedFlightRealizations.get(i).getRealizationId());
        }

        /* Alle geplanten Flüge mit dieser Airline werden gelöscht */
        this.flightMapper.deleteAllFlightsWithAirlineId(airId);

        /* Zudem werden alle FlightRealizations gelöscht, die einem nicht mehr existierenden Flight zugeordnet sind */
        for(int i=0; i<allRelatedFlights.size(); i++){
            this.flightRealizationMapper.deleteAllFlightRWithAssociatedFlightId(allRelatedFlights.get(i).getFlightId());
        }      

        /* Alle Flugzeuge dieser Airline werden in der Datenbank gelöscht */
        this.aircraftMapper.deleteAllAircraftsWithAirlineId(airId);

        /* Löscht die Airline in der Datenbank */
        this.airlineMapper.delete(a);
    }

    /**
     * Löscht das ausgewählte Flugzeug in der Datenbank
     *
     * @param craftId
     * @param craftName
     * @param airId
     * @param typeOfAircraftId
     * @throws java.rmi.RemoteException
     */
    public void deleteAircraft(int craftId, String craftName, int airId, int typeOfAircraftId) throws java.rmi.RemoteException {

        /* Aircraftobjekt wird mittels den übergebenen Werten angelegt */
        Aircraft a = new AircraftImpl(craftName, airId, typeOfAircraftId);
        a.setCraftId(craftId);

        /* Vector in den alle FlightRealizations gespeichert werden, die mit dem Aircraft durchgeführt werden sollten das nun gelöscht wird und die daher ebenfalls gelöscht werden */
        Vector<FlightRealization> allRelatedFlightRealizations = this.flightRealizationMapper.findAllFlightRAssociatedWithAircraftId(craftId);

        /* Alle Bookings, die eine betroffene FlightRealization beinhalten, werden gelöscht */
        for(int i=0; i<allRelatedFlightRealizations.size();i++){
            this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(allRelatedFlightRealizations.get(i).getRealizationId());
        }

        /* Löscht alle Flüge die von diesem Flugzeug hätten durchgeführt werden sollen */
        this.flightRealizationMapper.deleteAllFlightRWithAssociatedAircraftId(craftId);
        
        /* Löscht das Flugzeug in der Datenbank */
        this.aircraftMapper.delete(a);
    }

    /**
     * Löscht den ausgewählten Flugzeugtyp in der Datenbank
     *
     * @param craftTypeId
     * @param craftTypeName
     * @param seatId
     * @throws java.rmi.RemoteException
     */
    public void deleteTypeOfAircraft(int craftTypeId, String craftTypeName, int seatId) throws java.rmi.RemoteException {

        /* TypeOfAircraftobjekt wird mittels den übergebenen Werten angelegt */
        TypeOfAircraft tOA = new TypeOfAircraftImpl(craftTypeName, seatId);
        tOA.setCraftTypeId(craftTypeId);

        /* Vector der alle Aircrafts vom TypeOfAircraft enthält der gelöscht werden soll */
        Vector<Aircraft> allAircraftsWithTypeOfAircraftId = this.aircraftMapper.findByTypeOfAircraftId(craftTypeId);

        /* Vector der alle FlightRealizations mit dem entsprechenden Aircraft enthält */
        Vector<FlightRealization> allFlightRealizationsWithAircraftId = new Vector<FlightRealization>();

        /* Hier werden die FlightRealizations, die mit dem zu löschenden TypeOfAircraft durchgeführt werden sollten, in den den entsprechenden Vector gespeichert */
        for(int i = 0; i<allAircraftsWithTypeOfAircraftId.size(); i++) {
            /* Jede einzelne FlightRealization auslesen und in einem temporären Vector zwischenspeichern */
            Vector<FlightRealization> TempVector = flightRealizationMapper.findAllFlightRAssociatedWithAircraftId(allAircraftsWithTypeOfAircraftId.get(i).getCraftId());
            /* Gefundene FlightRealization in den entsprechenden Vector speichern */
            allFlightRealizationsWithAircraftId.addAll(TempVector);
        }

        /* Alle Bookings löschen, die mit den entsprechenden FlightRealizations zusammenhängen */
        for(int i = 0; i<allFlightRealizationsWithAircraftId.size(); i++){
            this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(allFlightRealizationsWithAircraftId.get(i).getRealizationId());
        }
     
        /* Alle FlightRealizations, die vom entsprechenden TypeOfAircraft durchgeführt werden sollten, werden gelöscht */
        for(int i = 0; i<allFlightRealizationsWithAircraftId.size(); i++){
            this.flightRealizationMapper.delete(allFlightRealizationsWithAircraftId.get(i));
        }

        /* Löscht die entsprechenden Aircrafts, die sonst ohne TypeOfAircraft wäre */
        this.aircraftMapper.deleteAllAircraftsWithTypeOfAircraftId(craftTypeId);

        /* Löscht den TypeOfAircraft in der Datenbank */
        this.typeOfAircraftMapper.delete(tOA);
    }

    /**
     * Löscht einen Flug vom Flugplan in der Datenbank
     *
     * @param flightId
     * @param timeOfDeparture
     * @param dayOfDeparture
     * @param timeOfArrival
     * @param dayOfArrival
     * @param departureAirportId
     * @param arrivalAirportId
     * @param airlineId
     * @throws java.rmi.RemoteException
     */
    public void deleteFlight(int flightId, String timeOfDeparture, String dayOfDeparture,
            String timeOfArrival, String dayOfArrival, String departureAirportId, String arrivalAirportId, int airlineId)
                throws java.rmi.RemoteException {

        /* Flightobjekt wird mittels den übergebenen Werten angelegt */
        Flight f = new FlightImpl(timeOfDeparture, dayOfDeparture, timeOfArrival, dayOfArrival, departureAirportId, arrivalAirportId, airlineId);
        f.setFlightId(flightId);

        /* Vector in den alle FlightRealizations gespeichert werden, die mit dem zu löschenden Flug in Verbindung stehen */
        Vector<FlightRealization> allRelatedFlightRealizations = this.flightRealizationMapper.findAllFlightRAssociatedWithFlightId(flightId);

        /* Alle Bookings, die eine betroffene FlightRealization beinhalten, werden gelöscht */
        for(int i=0; i<allRelatedFlightRealizations.size();i++){
            this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(allRelatedFlightRealizations.get(i).getRealizationId());
        }

        /* Löscht die FlightRealization die in Verbindung zum aktuellen Flug steht */
        this.flightRealizationMapper.deleteAllFlightRWithAssociatedFlightId(flightId);
        
        /* Löscht den geplanten Flug */
        this.flightMapper.delete(f);
    }

    /**
     * Löscht einen Flug in der Datenbank
     *
     * @param realizationId
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param flightId
     * @param aircraftId
     * @throws java.rmi.RemoteException
     */
    public void deleteFlightRealization(int realizationId, Date dateOfDeparture, Date dateOfArrival, int flightId, int aircraftId)
            throws java.rmi.RemoteException {

        /* FlightRealizationobjekt wird mittels den übergebenen Werten angelegt */
        FlightRealization fR = new FlightRealizationImpl(dateOfDeparture, dateOfArrival, flightId, aircraftId);
        fR.setRealizationId(realizationId);

        /* Löscht alle Buchungen auf diesen Flug in der Datenbank */
        this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(realizationId);

        /* Löscht den Flug in der Datenbank */
        this.flightRealizationMapper.delete(fR);
    }

    /**
     * Löscht den ausgewählten Passagier in der Datenbank
     *
     * @param passengerId
     * @param firstName
     * @param lastName
     * @param street
     * @param postcode
     * @param city
     * @throws java.rmi.RemoteException
     */
    public void deletePassenger(int passengerId, String firstName, String lastName, String street, int postcode, String city)
            throws java.rmi.RemoteException {

        /* Passengerobjekt wird mittels den übergebenen Werten angelegt */
        Passenger p = new PassengerImpl(firstName, lastName, street, postcode, city);
        p.setPassengerId(passengerId);

        /* Zunächst werden alle Buchungen des Passagiers in der Datenbank gelöscht */
        this.bookingMapper.deleteAllBookingsFromPassenger(passengerId);

        /* Anschließend wird der Passagier in der Datenbank gelöscht */
        this.passengerMapper.delete(p);
    }

    /**
     * Löscht die ausgewählte Sitzstruktur in der Datenbank
     *
     * @param seatId
     * @param seatsPerRow
     * @param numberOfRows
     * @throws java.rmi.RemoteException
     */
    public void deleteSeat(int seatId, int seatsPerRow, int numberOfRows) throws java.rmi.RemoteException {

        /* Seatobjekt wird mittels den übergebenen Werten angelegt */
        Seat s = new SeatImpl(seatsPerRow, numberOfRows);
        s.setSeatId(seatId);

        /* Vector 1 erzeugen, in den alle TypeOfAircrafts mit der zu löschenden Sitzstruktur gespeichert werden */
        Vector<TypeOfAircraft> allTypeOfAircraftsWithSeatId = this.typeOfAircraftMapper.findAllTypesAssociatedWithSeatId(seatId);

        /* Vector 2 erzeugen, in den alle Aircrafts von den oben gespeicherten TypeOfAircrafts gespeichert werden */
        Vector<Aircraft> allAircraftsWithTypeOfAircraftId = new Vector<Aircraft>();

        /* Vector 3 erzeugen, in den alle FlightRealizations mit den oben genannten Aircrafts gespeichert werden */
        Vector<FlightRealization> allFlightRealizationsWithAircraftId = new Vector<FlightRealization>();

        /* Vector 2 mit allen Aircrafts vom entsprechenden TypeOfAircraft belegen */
        for(int i = 0; i<allTypeOfAircraftsWithSeatId.size(); i++) {
            Vector<Aircraft> tempVector = aircraftMapper.findByTypeOfAircraftId(allTypeOfAircraftsWithSeatId.get(i).getCraftTypeId());
            allAircraftsWithTypeOfAircraftId.addAll(tempVector);
        }

        /* Vector 3 mit allen FlightRealizations belegen, die mit dem entsprechenden Aircraft durchgeführt werden sollten */
        for(int i = 0; i<allAircraftsWithTypeOfAircraftId.size(); i++) {
            Vector<FlightRealization> tempVector = flightRealizationMapper.findAllFlightRAssociatedWithAircraftId(allAircraftsWithTypeOfAircraftId.get(i).getCraftId());
            allFlightRealizationsWithAircraftId.addAll(tempVector);
        }

        /* Löscht alle Buchungen die mit dieser Sitzstruktur in Verbindung stehen in der Datenbank */
        for(int i = 0; i<allFlightRealizationsWithAircraftId.size(); i++) {
            this.bookingMapper.deleteAllBookingsAssociatedWithFlightRId(allFlightRealizationsWithAircraftId.get(i).getRealizationId());
        }

        /* Löscht alle Flüge die mit dieser Sitzstruktur in Verbindung stehen in der Datenbank */
        for(int i = 0; i<allFlightRealizationsWithAircraftId.size(); i++) {
            this.flightRealizationMapper.delete(allFlightRealizationsWithAircraftId.get(i));
        }

        /* Löscht alle Flugzeuge die mit dieser Sitzstruktur in Verbindung stehen in der Datenbank */
        for(int i = 0; i<allAircraftsWithTypeOfAircraftId.size(); i++) {
            this.aircraftMapper.delete(allAircraftsWithTypeOfAircraftId.get(i));
        }

        /* Löscht alle Flugzeugtypen die mit dieser Sitzstruktur in Verbindung stehen in der Datenbank */
        for(int i = 0; i<allTypeOfAircraftsWithSeatId.size(); i++) {
            this.typeOfAircraftMapper.delete(allTypeOfAircraftsWithSeatId.get(i));
        }
           
        /* Löscht die Sitzstruktur */
        this.seatMapper.delete(s);
    }

    /**
     * Löscht die ausgewählte Buchung in der Datenbank
     *
     * @param bookingId
     * @param passengerId
     * @param realizationId
     * @throws java.rmi.RemoteException
     */
    public void deleteBooking(int bookingId, int passengerId, int realizationId) throws java.rmi.RemoteException {

        Booking b = new BookingImpl(passengerId, realizationId);
        b.setBookingId(bookingId);

        this.bookingMapper.delete(b);
    }

    /**
     * Löscht alle Buchungen des Passagiers
     *
     * @param passengerId
     * @throws java.rmi.RemoteException
     */
    public void deleteAllBookingsFromPassenger(int passengerId) throws java.rmi.RemoteException {

        /* Löscht alle Buchungen des Passagiers */
        this.bookingMapper.deleteAllBookingsFromPassenger(passengerId);
    }


    /*      -       getAll-Methoden     -       */


    /**
     * Gibt alle Flughäfen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllAirportsForTable() throws java.rmi.RemoteException {
        
        // Vector mit allen Airports aus DB
        Vector<Airport> allAirports = this.airportMapper.findAll();

        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allAirports.size(); i++) {

                Vector<String> TempString = new Vector<String>();

                    String internationalId = allAirports.get(i).getInternationalId();
                        TempString.addElement(internationalId);

                    String portName = allAirports.get(i).getPortName();
                        TempString.addElement(portName);

                    String portCity = allAirports.get(i).getPortCity();
                        TempString.addElement(portCity);

                    String portCountry = allAirports.get(i).getPortCountry();
                        TempString.addElement(portCountry);

                tableData.addElement(TempString);
            }

        return tableData;
    }

    /**
     * Gibt alle Flughäfen für die ComboBoxen aus
     *
     * @return Vector<Airport>
     * @throws java.rmi.RemoteException
     */
    public Vector<Airport> getAllAirportsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Flughäfen aus der Datenbank darin speichern
        Vector<Airport> allAirportsForComboBox = this.airportMapper.findAll();

        return allAirportsForComboBox;
    }

    /**
     * Gibt die Städtenamen sowie die internationalen Kürzel aller Flughäfen für die ComboBoxen aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllAirportCitiesAndIdsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Flughäfen aus der Datenbank darin speichern
        Vector<Airport> allAirports = this.airportMapper.findAll();
        // Vector erzeugen, in den über die nachfolgende for-Schleife die Städtenamen aller Flughäfen gespeichert werden
        Vector<String> cityAndIdOfAirports = new Vector<String>();
            // Standardwert für Vector definieren
            cityAndIdOfAirports.add("Bitte auswählen");

        for(int i = 0; i<allAirports.size(); i++) {
            // Das internationale Kürzel des aktuellen Flughafens auslesen und in Stringvariable speichern
            String intId = allAirports.get(i).getInternationalId();
            // Stadt des aktuellen Flughafens auslesen und in Stringvariable speichern
            String airportCity = allAirports.get(i).getPortCity();
            // Int. Kürzel und Städtenamen in neuem String zusammenführen
            String cityAndIntIdOfAirport = airportCity + " (" + intId + ")";
            // Stringvariable in Vector speichern
            cityAndIdOfAirports.add(cityAndIntIdOfAirport);
        }

        return cityAndIdOfAirports;
    }

    /**
     * Gibt alle Fluglinien für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllAirlinesForTable() throws java.rmi.RemoteException {

        // Vector mit allen Fluglinien die in der DB vorhanden sind belegen.
        Vector<Airline> allAirlines = this.airlineMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        for(int i = 0; i<allAirlines.size(); i++) {

            // Temporären Vector erzeugen in den die Daten der aktuellen Airline gespeichert werden
            Vector<String> TempString = new Vector<String>();

                // Id der aktuellen Airline auslesen
                String airlineId = String.valueOf(allAirlines.get(i).getAirId());
                    TempString.add(airlineId);
                // Namen der aktuellen Airline auslesen
                String airlineName = allAirlines.get(i).getAirName();
                    TempString.add(airlineName);

            // Temporären Vector in Vector mit Daten für die JTable speichern
            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Fluglinien für die ComboBox aus
     *
     * @return Vector<Airline>
     * @throws java.rmi.RemoteException
     */
    public Vector<Airline> getAllAirlinesForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Fluglinien aus der Datenbank darin speichern
        Vector<Airline> allAirlinesForComboBox = this.airlineMapper.findAll();

        return allAirlinesForComboBox;
    }

    /**
     * Gibt die Namen der Fluglinien für die ComboBoxen aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllAirlineNamesForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Fluglinien aus der Datenbank darin speichern
        Vector<Airline> allAirlines = this.airlineMapper.findAll();
        // Vector erzeugen, in den über die nachfolgende for-Schleife die Bezeichnungen aller Fluglinien gespeichert werden
        Vector<String> allAirlineNames = new Vector<String>();
            // Standardwert für Vector definieren
            allAirlineNames.add("Bitte auswählen");

        for(int i = 0; i<allAirlines.size(); i++) {
            // Bezeichnung des aktuellen Flugzeugtypes auslesen und in Stringvariable speichern
            String airlineName = String.valueOf(allAirlines.get(i).getAirName());
            // Stringvariable in Vector speichern
            allAirlineNames.add(airlineName);
        }

        return allAirlineNames;
    }

    /**
     * Gibt alle Flugzeuge für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllAircraftsForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flugzeugen die in der DB vorhanden sind belegen.
        Vector<Aircraft> allAircrafts = this.aircraftMapper.findAll();

        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        for(int i = 0; i<allAircrafts.size(); i++) {

            // Temporären Vector erzeugen in den die Daten des aktuellen Flugzeuges gespeichert werden
            Vector<String> TempString = new Vector<String>();

                // Id des aktuellen Flugzeuges auslesen
                String craftId = String.valueOf(allAircrafts.get(i).getCraftId());
                    TempString.add(craftId);

                // Name des aktuellen Flugzeuges auslesen
                String craftName = allAircrafts.get(i).getCraftName();
                    TempString.add(craftName);

                // Name des Flugzeugtypes des aktuellen Flugzeuges auslesen
                TypeOfAircraft tOA = this.typeOfAircraftMapper.findById(allAircrafts.get(i).getTypeOfAircraftId());
                    String typeOfAircraftName = tOA.getCraftTypeName();
                        TempString.add(typeOfAircraftName);

                // Name der Airline des aktuellen Flugzeuges auslesen
                Airline a = this.airlineMapper.findById(allAircrafts.get(i).getAirlineId());
                    String airlineName = a.getAirName();
                        TempString.add(airlineName);
                            
            // Temporären Vector in Vector mit Daten für die JTable speichern
            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Flugzeuge für die ComboBox aus
     *
     * @return Vector<Aircraft>
     * @throws java.rmi.RemoteException
     */
    public Vector<Aircraft> getAllAircraftsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Flugzeuge aus der Datenbank darin speichern
        Vector<Aircraft> allAircraftsForComboBox = this.aircraftMapper.findAll();

        return allAircraftsForComboBox;
    }

    /**
     * Gibt alle Flugzeugtypen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllTypeOfAircraftsForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flugzeugtypen die in der DB vorhanden sind belegen.
        Vector<TypeOfAircraft> allTypeOfAircrafts = this.typeOfAircraftMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        for(int i = 0; i<allTypeOfAircrafts.size(); i++) {

            // Temporären Vector erzeugen in den die Daten des aktuellen Flugzeugtyps gespeichert werden
            Vector<String> TempString = new Vector<String>();
            
                // Id des aktuellen Flugzeugtyps auslesen und in temporären Vector speichern
                String typeOfAircraftIdAsString = String.valueOf(allTypeOfAircrafts.get(i).getCraftTypeId());
                    TempString.add(typeOfAircraftIdAsString);
                // Name des aktuellen Flugzeugtyps auslesen und in temporären Vector speichern
                String typeOfAircraftName = allTypeOfAircrafts.get(i).getCraftTypeName();
                    TempString.add(typeOfAircraftName);
                // Sitzstruktur des aktuellen Flugzeugtyps auslesen und in temporären Vector speichern
                int seatId = allTypeOfAircrafts.get(i).getSeatId();
                    String seatIdAsString = "Sitzstruktur " + String.valueOf(seatId);
                        Seat s = this.seatMapper.findById(seatId);
                            String seatIdAndDetailedInformations = seatIdAsString + " (" + s.getNumberOfAllSeats() + " Sitzplätze, " +
                                                                    "verteilt auf " + s.getNumberOfRows() + " Reihen mit je " +
                                                                    s.getSeatsPerRow() + " Sitzplätzen)";
                                TempString.add(seatIdAndDetailedInformations);

            // Temporären Vector in Vector mit Daten für die JTable speichern
            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Flugzeugtypen für die ComboBox aus
     *
     * @return Vector<TypeOfAircraft>
     * @throws java.rmi.RemoteException
     */
    public Vector<TypeOfAircraft> getAllTypeOfAircraftsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Flugzeugtypen aus der Datenbank darin speichern
        Vector<TypeOfAircraft> allTypeOfAircraftsForComboBox = this.typeOfAircraftMapper.findAll();
        
        return allTypeOfAircraftsForComboBox;
    }

    /**
     * Gibt Informationen aller Flugzeugtypen für die ComboBox aus
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllTypeOfAircraftInformationsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Flugzeugtypen aus der Datenbank darin speichern
        Vector<TypeOfAircraft> allTypeOfAircrafts = this.typeOfAircraftMapper.findAll();
        // Vector erzeugen, in den über die nachfolgende for-Schleife die Bezeichnungen aller Flugzeugtypen gespeichert werden
        Vector<String> allTypeOfAircraftNames = new Vector<String>();
            // Standardwert für Vector definieren
            allTypeOfAircraftNames.add("Bitte auswählen");

        for(int i = 0; i<allTypeOfAircrafts.size(); i++) {
            // Bezeichnung des aktuellen Flugzeugtypes auslesen und in Stringvariable speichern
            String craftTypeName = String.valueOf(allTypeOfAircrafts.get(i).getCraftTypeName());
            // Stringvariable in Vector speichern
            allTypeOfAircraftNames.add(craftTypeName);
        }

        return allTypeOfAircraftNames;
    }

    /**
     * Gibt alle Flüge für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                Vector<String> TempString = new Vector<String>();

                    // Flugnummer des aktuellen Fluges auslesen
                    int flightId = allFlights.get(i).getFlightId();
                    // Aktuelles Flugobjekt auslesen
                    Flight currentFlight = this.flightMapper.findById(flightId);
                    // Den Startflughafen des aktuellen Fluges auslesen
                    Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                    // Den Zielflughafen des aktuellen Fluges auslesen
                    Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                    // Die Fluglinie des aktuellen Fluges auslesen
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                        String flightIdAsString = String.valueOf(flightId);
                            TempString.add(flightIdAsString);
                        // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                        String dayOfDeparture = allFlights.get(i).getDayOfDeparture();
                            TempString.add(dayOfDeparture);
                        // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                        String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                            TempString.add(timeOfDeparture);
                        // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                        String dayOfArrival = allFlights.get(i).getDayOfArrival();
                            TempString.add(dayOfArrival);
                        // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                        String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                            TempString.add(timeOfArrival);
                        // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Die Airline des aktuellen Fluges in temporären Vector speichern
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                tableData.addElement(TempString);
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Montag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnMondayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Montag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Montag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Dienstag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnTuesdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Dienstag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Dienstag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Mittwoch für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnWednesdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Mittwoch ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Mittwoch")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Donnerstag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnThursdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Donnerstag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Donnerstag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Freitag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnFridayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Freitag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Freitag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Samstag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnSaturdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Samstag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Samstag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flüge am Sonntag für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightsOnSundayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flights die in der DB vorhanden sind belegen.
        Vector<Flight> allFlights = this.flightMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

            for(int i = 0; i<allFlights.size(); i++) {

                // Das aktuelle Flug-Objekt auslesen
                Flight currentFlight = this.flightMapper.findById(allFlights.get(i).getFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Sonntag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Sonntag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                        // Den Startflughafen des aktuellen Fluges auslesen
                        Airport departureAirport = this.airportMapper.findByInternationalId(currentFlight.getDepartureAirportId());
                        // Den Zielflughafen des aktuellen Fluges auslesen
                        Airport arrivalAirport = this.airportMapper.findByInternationalId(currentFlight.getArrivalAirportId());
                        // Die Fluglinie des aktuellen Fluges auslesen
                        Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                            // Die Flugnummer des aktuellen Fluges in temporären Vector speichern
                            String flightIdAsString = String.valueOf(currentFlight.getFlightId());
                                TempString.add(flightIdAsString);
                            // Den Abflugwochentag des aktuellen Fluges in temporären Vector speichern
                            TempString.add(dayOfDeparture);
                            // Die Abfluguhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfDeparture = allFlights.get(i).getTimeOfDeparture();
                                TempString.add(timeOfDeparture);
                            // Den Ankunftswochentag des aktuellen Fluges in temporären Vector speichern
                            String dayOfArrival = allFlights.get(i).getDayOfArrival();
                                TempString.add(dayOfArrival);
                            // Die Ankunftsuhrzeit des aktuellen Fluges in temporären Vector speichern
                            String timeOfArrival = allFlights.get(i).getTimeOfArrival();
                                TempString.add(timeOfArrival);
                            // Den Startflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfDepartureCity = departureAirport.getPortCity();
                                String airportOfDepartureId = departureAirport.getInternationalId();
                                    String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                        TempString.addElement(airportOfDepartureCityAndId);
                            // Den Zielflughafen des aktuellen Fluges in temporären Vector speichern
                            String airportOfArrivalCity = arrivalAirport.getPortCity();
                                String airportOfArrivalId = arrivalAirport.getInternationalId();
                                    String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                        TempString.addElement(airportOfArrivalCityAndId);
                            // Die Airline des aktuellen Fluges in temporären Vector speichern
                            String airlineName = currentAirline.getAirName();
                                TempString.addElement(airlineName);

                    // Den temporären Vector in den Vector mit den Daten für die JTable speichern
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge und weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsForTable() throws java.rmi.RemoteException {
        
        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                Vector<String> TempString = new Vector<String>();

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Abflughafen-Objekt
                Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                // Zielflughafen-Objekt
                Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                    String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                        TempString.addElement(realizationId);

                    String dayOfDeparture = currentFlight.getDayOfDeparture();
                        TempString.addElement(dayOfDeparture);

                    String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                        TempString.addElement(dateOfDeparture);

                    String timeOfDeparture = currentFlight.getTimeOfDeparture();
                        TempString.addElement(timeOfDeparture);

                    String dayOfArrival = currentFlight.getDayOfArrival();
                        TempString.addElement(dayOfArrival);

                    String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                        TempString.addElement(dateOfArrival);

                    String timeOfArrival = currentFlight.getTimeOfArrival();
                        TempString.addElement(timeOfArrival);

                    String airportOfDepartureCity = departureAirport.getPortCity();
                        String airportOfDepartureId = departureAirport.getInternationalId();
                            String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                TempString.addElement(airportOfDepartureCityAndId);

                    String airportOfArrivalCity = arrivalAirport.getPortCity();
                        String airportOfArrivalId = arrivalAirport.getInternationalId();
                            String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                TempString.addElement(airportOfArrivalCityAndId);

                    String airlineName = currentAirline.getAirName();
                        TempString.addElement(airlineName);


                tableData.addElement(TempString);
            }
        
        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Montag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnMondayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Montag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Montag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }
        
        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Dienstag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnTuesdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Dienstag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Dienstag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Mittwoch sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnWednesdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Mittwoch ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Mittwoch")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Donnerstag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnThursdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Donnerstag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Donnerstag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Freitag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnFridayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Freitag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Freitag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Samstag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnSaturdayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Samstag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Samstag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }
            
        return tableData;
    }

    /**
     * Gibt alle ausführenden Flüge am Sonntag sowie weitere relevante Daten für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllFlightRealizationsOnSundayForTable() throws java.rmi.RemoteException {

        // Vector mit allen Flightrealizations die in der DB vorhanden sind belegen.
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

            for(int i = 0; i<allFlightRealizations.size(); i++) {

                // Flight-Objekt des aktuellen FlightRealization-Objektes auslesen
                Flight currentFlight = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                // Wochentag des Abflugtages auslesen
                String dayOfDeparture = currentFlight.getDayOfDeparture();
                // Prüfen ob der Wochentag des aktuellen Fluges ein Sonntag ist, wenn ja Daten auslesen und in Vector für JTable speichern
                if(dayOfDeparture.equals("Sonntag")) {

                    // Temporären Vector erzeugen in den die Daten des aktuellen Fluges gespeichert werden
                    Vector<String> TempString = new Vector<String>();

                    // Abflughafen-Objekt
                    Airport departureAirport = this.flightMapper.getDepartureAirportOfFlight(currentFlight);
                    // Zielflughafen-Objekt
                    Airport arrivalAirport = this.flightMapper.getArrivalAirportOfFlight(currentFlight);
                    // Airline-Objekt von der Fluglinie, die den aktuellen Flug ausführen wird.
                    Airline currentAirline = this.airlineMapper.findById(currentFlight.getAirlineId());

                        // Flugnummer in Vector schreiben
                        String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());
                            TempString.addElement(realizationId);
                        // Abflugtag in Vector schreiben
                        TempString.addElement(dayOfDeparture);
                        // Abflugdatum in Vector schreiben
                        String dateOfDeparture = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfDeparture()));
                            TempString.addElement(dateOfDeparture);
                        // Abflugzeit in Vector schreiben
                        String timeOfDeparture = currentFlight.getTimeOfDeparture();
                            TempString.addElement(timeOfDeparture);
                        // Ankunftstag in Vector schreiben
                        String dayOfArrival = currentFlight.getDayOfArrival();
                            TempString.addElement(dayOfArrival);
                        // Ankunftsdatum in Vector schreiben
                        String dateOfArrival = String.valueOf(r.convertDateToStringWithoutWeekday(allFlightRealizations.get(i).getDateOfArrival()));
                            TempString.addElement(dateOfArrival);
                        // Ankunftszeit in Vector schreiben
                        String timeOfArrival = currentFlight.getTimeOfArrival();
                            TempString.addElement(timeOfArrival);
                        // Startflughafen in Vector schreiben
                        String airportOfDepartureCity = departureAirport.getPortCity();
                            String airportOfDepartureId = departureAirport.getInternationalId();
                                String airportOfDepartureCityAndId = airportOfDepartureCity + " (" + airportOfDepartureId + ")";
                                    TempString.addElement(airportOfDepartureCityAndId);
                        // Zielflughafen in Vector schreiben
                        String airportOfArrivalCity = arrivalAirport.getPortCity();
                            String airportOfArrivalId = arrivalAirport.getInternationalId();
                                String airportOfArrivalCityAndId = airportOfArrivalCity + " (" + airportOfArrivalId + ")";
                                    TempString.addElement(airportOfArrivalCityAndId);
                        // Airline des Fluges in Vector schreiben
                        String airlineName = currentAirline.getAirName();
                            TempString.addElement(airlineName);

                    // Sind alle Daten in den temporären Vector gespeichert wird dieser in den Vector mit den Daten für die JTable gespeichert
                    tableData.addElement(TempString);
                }
            }

        return tableData;
    }

    /**
     * Gibt alle Flugdurchführungen für die ComboBox aus
     *
     * @return Vector<FlightRealization>
     * @throws java.rmi.RemoteException
     */
    public Vector<FlightRealization> getAllFlightRealizationsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen in den alle Passenger-Objekte aus der Datenbank gespeichert werden
        Vector<FlightRealization> allFlightRealizationsForComboBox = this.flightRealizationMapper.findAll();

        return allFlightRealizationsForComboBox;
    }

    /**
     * Gibt Informationen zu allen Flugdurchführungen für die ComboBox zurück
     *
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllFlightRealizationInfosForComboBox() throws java.rmi.RemoteException {

        // Alle FlightRealizations aus Datenbank auslesen
        Vector<FlightRealization> allFlightRealizations = this.flightRealizationMapper.findAll();
        // Alle Informationen der Flüge auslesen und in Vector speichern
        Vector<String> allFlightRealzationInformations = new Vector<String>();
        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();
        
            allFlightRealzationInformations.add("Wählen Sie hier eine Flugdurchführung aus, um nur deren Buchungen anzuzeigen");

        for(int i = 0; i<allFlightRealizations.size(); i++) {
            // realizationId auslesen
            String realizationId = String.valueOf(allFlightRealizations.get(i).getRealizationId());

            FlightRealization fr = this.flightRealizationMapper.findById(allFlightRealizations.get(i).getRealizationId());
                Date DateOfDeparture = fr.getDateOfDeparture();
                    String dateOfDepartureAsString = String.valueOf(r.convertDateToString(DateOfDeparture));

            Flight f = this.flightMapper.findById(allFlightRealizations.get(i).getRelatedFlightId());
                String timeOfDeparture = f.getTimeOfDeparture();
                Airport departureAirport = this.airportMapper.findByInternationalId(f.getDepartureAirportId());
                    String departureAirportAsString = departureAirport.getPortCity() + " (" + departureAirport.getInternationalId() + ")";
                Airport arrivalAirport = this.airportMapper.findByInternationalId(f.getArrivalAirportId());
                    String arrivalAirportAsString = arrivalAirport.getPortCity() + " (" + arrivalAirport.getInternationalId() + ")";

            String flightDetails = "Flug " + realizationId + ", am " + dateOfDepartureAsString + " um " + timeOfDeparture + "Uhr von " +
                                        departureAirportAsString + " nach " + arrivalAirportAsString;
            
            allFlightRealzationInformations.add(flightDetails);
        }

        return allFlightRealzationInformations;
    }

    /**
     * Gibt alle Passagiere für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Passagiere aus der Datenbank hineinspeichern
        Vector<Passenger> allPassengers = this.passengerMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
        for(int i = 0; i<allPassengers.size(); i++) {

            // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Passagier-Objekte zwischengespeichert werden
            Vector<String> TempString = new Vector<String>();

                /* Anschließend werden alle Informationen über den Passagier ausgelesen und
                 * in den temporären Vector gespeichert. */
                String passengerIdAsString = String.valueOf(allPassengers.get(i).getPassengerId());
                    TempString.addElement(passengerIdAsString);

                String firstName = allPassengers.get(i).getFirstName();
                    TempString.addElement(firstName);

                String lastName = allPassengers.get(i).getLastName();
                    TempString.addElement(lastName);

                String street = allPassengers.get(i).getStreet();
                    TempString.addElement(street);

                String postcodeAsString = String.valueOf(allPassengers.get(i).getPostcode());
                        TempString.addElement(postcodeAsString);

                String city = allPassengers.get(i).getCity();
                    TempString.addElement(city);

            /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
             * wird dieser in den Vector mit den Daten für die JTable gespeichert */
            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen A-E liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromAtoEForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Passagiere aus der Datenbank hineinspeichern
        Vector<Passenger> allPassengersFromAtoE = this.passengerMapper.findAllPassengersFromAtoE();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        /* Prüfen ob der Vector mit Passagier-Objekten leer ist, wenn nicht,
         * werden die vorhandenen Objekte in den Vector für die JTable gespeichert */
        if(allPassengersFromAtoE.size() != 0) {

            // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
            for(int i = 0; i<allPassengersFromAtoE.size(); i++) {

                // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Passagier-Objekte zwischengespeichert werden
                Vector<String> TempString = new Vector<String>();

                    /* Anschließend werden alle Informationen über den Passagier ausgelesen und
                     * in den temporären Vector gespeichert. */
                    String passengerIdAsString = String.valueOf(allPassengersFromAtoE.get(i).getPassengerId());
                        TempString.addElement(passengerIdAsString);

                    String firstName = allPassengersFromAtoE.get(i).getFirstName();
                        TempString.addElement(firstName);

                    String lastName = allPassengersFromAtoE.get(i).getLastName();
                        TempString.addElement(lastName);

                    String street = allPassengersFromAtoE.get(i).getStreet();
                        TempString.addElement(street);

                    String postcodeAsString = String.valueOf(allPassengersFromAtoE.get(i).getPostcode());
                        TempString.addElement(postcodeAsString);

                    String city = allPassengersFromAtoE.get(i).getCity();
                        TempString.addElement(city);

                /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
                 * wird dieser in den Vector mit den Daten für die JTable gespeichert */
                tableData.addElement(TempString);
            }
        }
        
        return tableData;
    }

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen F-J liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromFtoJForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Passagiere aus der Datenbank hineinspeichern
        Vector<Passenger> allPassengersFromFtoJ = this.passengerMapper.findAllPassengersFromFtoJ();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        /* Prüfen ob der Vector mit Passagier-Objekten leer ist, wenn nicht,
         * werden die vorhandenen Objekte in den Vector für die JTable gespeichert */
        if(allPassengersFromFtoJ.size() != 0) {

            // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
            for(int i = 0; i<allPassengersFromFtoJ.size(); i++) {

                // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Passagier-Objekte zwischengespeichert werden
                Vector<String> TempString = new Vector<String>();

                    /* Anschließend werden alle Informationen über den Passagier ausgelesen und
                     * in den temporären Vector gespeichert. */
                    String passengerIdAsString = String.valueOf(allPassengersFromFtoJ.get(i).getPassengerId());
                        TempString.addElement(passengerIdAsString);

                    String firstName = allPassengersFromFtoJ.get(i).getFirstName();
                        TempString.addElement(firstName);

                    String lastName = allPassengersFromFtoJ.get(i).getLastName();
                        TempString.addElement(lastName);

                    String street = allPassengersFromFtoJ.get(i).getStreet();
                        TempString.addElement(street);

                    String postcodeAsString = String.valueOf(allPassengersFromFtoJ.get(i).getPostcode());
                        TempString.addElement(postcodeAsString);

                    String city = allPassengersFromFtoJ.get(i).getCity();
                        TempString.addElement(city);

                /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
                 * wird dieser in den Vector mit den Daten für die JTable gespeichert */
                tableData.addElement(TempString);
            }
        }

        return tableData;
    }

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen K-O liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromKtoOForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Passagiere aus der Datenbank hineinspeichern
        Vector<Passenger> allPassengersFromKtoO = this.passengerMapper.findAllPassengersFromKtoO();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        /* Prüfen ob der Vector mit Passagier-Objekten leer ist, wenn nicht,
         * werden die vorhandenen Objekte in den Vector für die JTable gespeichert */
        if(allPassengersFromKtoO.size() != 0) {

            // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
            for(int i = 0; i<allPassengersFromKtoO.size(); i++) {

                // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Passagier-Objekte zwischengespeichert werden
                Vector<String> TempString = new Vector<String>();

                    /* Anschließend werden alle Informationen über den Passagier ausgelesen und
                     * in den temporären Vector gespeichert. */
                    String passengerIdAsString = String.valueOf(allPassengersFromKtoO.get(i).getPassengerId());
                        TempString.addElement(passengerIdAsString);

                    String firstName = allPassengersFromKtoO.get(i).getFirstName();
                        TempString.addElement(firstName);

                    String lastName = allPassengersFromKtoO.get(i).getLastName();
                        TempString.addElement(lastName);

                    String street = allPassengersFromKtoO.get(i).getStreet();
                        TempString.addElement(street);

                    String postcodeAsString = String.valueOf(allPassengersFromKtoO.get(i).getPostcode());
                        TempString.addElement(postcodeAsString);

                    String city = allPassengersFromKtoO.get(i).getCity();
                        TempString.addElement(city);

                /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
                 * wird dieser in den Vector mit den Daten für die JTable gespeichert */
                tableData.addElement(TempString);
            }
        }

        return tableData;
    }

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen P-T liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromPtoTForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Passagiere aus der Datenbank hineinspeichern
        Vector<Passenger> allPassengersFromPtoT = this.passengerMapper.findAllPassengersFromPtoT();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        /* Prüfen ob der Vector mit Passagier-Objekten leer ist, wenn nicht,
         * werden die vorhandenen Objekte in den Vector für die JTable gespeichert */
        if(allPassengersFromPtoT.size() != 0) {

            // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
            for(int i = 0; i<allPassengersFromPtoT.size(); i++) {

                // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Passagier-Objekte zwischengespeichert werden
                Vector<String> TempString = new Vector<String>();

                    /* Anschließend werden alle Informationen über den Passagier ausgelesen und
                     * in den temporären Vector gespeichert. */
                    String passengerIdAsString = String.valueOf(allPassengersFromPtoT.get(i).getPassengerId());
                        TempString.addElement(passengerIdAsString);

                    String firstName = allPassengersFromPtoT.get(i).getFirstName();
                        TempString.addElement(firstName);

                    String lastName = allPassengersFromPtoT.get(i).getLastName();
                        TempString.addElement(lastName);

                    String street = allPassengersFromPtoT.get(i).getStreet();
                        TempString.addElement(street);

                    String postcodeAsString = String.valueOf(allPassengersFromPtoT.get(i).getPostcode());
                        TempString.addElement(postcodeAsString);

                    String city = allPassengersFromPtoT.get(i).getCity();
                        TempString.addElement(city);

                /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
                 * wird dieser in den Vector mit den Daten für die JTable gespeichert */
                tableData.addElement(TempString);
            }
        }

        return tableData;
    }

    /**
     * Gibt alle Passagiere deren Nachnamen zwischen U-Z liegen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllPassengersFromUtoZForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Passagiere aus der Datenbank hineinspeichern
        Vector<Passenger> allPassengersFromUtoZ = this.passengerMapper.findAllPassengersFromUtoZ();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        /* Prüfen ob der Vector mit Passagier-Objekten leer ist, wenn nicht,
         * werden die vorhandenen Objekte in den Vector für die JTable gespeichert */
        if(allPassengersFromUtoZ.size() != 0) {

            // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
            for(int i = 0; i<allPassengersFromUtoZ.size(); i++) {

                // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Passagier-Objekte zwischengespeichert werden
                Vector<String> TempString = new Vector<String>();

                    /* Anschließend werden alle Informationen über den Passagier ausgelesen und
                     * in den temporären Vector gespeichert. */
                    String passengerIdAsString = String.valueOf(allPassengersFromUtoZ.get(i).getPassengerId());
                        TempString.addElement(passengerIdAsString);

                    String firstName = allPassengersFromUtoZ.get(i).getFirstName();
                        TempString.addElement(firstName);

                    String lastName = allPassengersFromUtoZ.get(i).getLastName();
                        TempString.addElement(lastName);

                    String street = allPassengersFromUtoZ.get(i).getStreet();
                        TempString.addElement(street);

                    String postcodeAsString = String.valueOf(allPassengersFromUtoZ.get(i).getPostcode());
                        TempString.addElement(postcodeAsString);

                    String city = allPassengersFromUtoZ.get(i).getCity();
                        TempString.addElement(city);

                /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
                 * wird dieser in den Vector mit den Daten für die JTable gespeichert */
                tableData.addElement(TempString);
            }
        }

        return tableData;
    }

    /**
     * Gibt alle Passagiere für die ComboBox aus
     *
     * @return Vector<Passenger>
     * @throws java.rmi.RemoteException
     */
    public Vector<Passenger> getAllPassengersForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen in den alle Passenger-Objekte aus der Datenbank gespeichert werden
        Vector<Passenger> allPassengersForComboBox = this.passengerMapper.findAll();

        return allPassengersForComboBox;
    }

    /**
     * Gibt alle Sitzstrukturen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllSeatsForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Sitzstrukturen darin speichern
        Vector<Seat> allSeats = this.seatMapper.findAll();

        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
        for(int i = 0; i<allSeats.size(); i++) {

            // Zunächst wird ein temporärer Vector angelegt in den die einzelnen Daten der  Seat-Objekte zwischengespeichert werden
            Vector<String> TempString = new Vector<String>();

            int seatId = allSeats.get(i).getSeatId();
                String seatIdAsString = String.valueOf(seatId);
                    TempString.add(seatIdAsString);

            int numberOfAllSeats = allSeats.get(i).getNumberOfAllSeats();
                String numberOfAllSeatsAsString = String.valueOf(numberOfAllSeats);
                    TempString.add(numberOfAllSeatsAsString);

            int seatsPerRow = allSeats.get(i).getSeatsPerRow();
                String seatsPerRowAsString = String.valueOf(seatsPerRow);
                    TempString.add(seatsPerRowAsString);

            int numberOfRows = allSeats.get(i).getNumberOfRows();
                String numberOfRowsAsString = String.valueOf(numberOfRows);
                    TempString.add(numberOfRowsAsString);

            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Sitzstrukturen für die ComboBox aus
     *
     * @return Vector<Seat>
     * @throws java.rmi.RemoteException
     */
    public Vector<Seat> getAllSeatsForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen in den alle Seat-Objekte aus der Datenbank gespeichert werden
        Vector<Seat> allSeatsForComboBox = this.seatMapper.findAll();

        return allSeatsForComboBox;
    }

    /**
     * Gibt Informationen über alle Sitzstrukturen für die ComboBox aus
     * 
     * @return Vector<String>
     * @throws java.rmi.RemoteException
     */
    public Vector<String> getAllSeatInformationForComboBox() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Sitzstrukturen aus der Datenbank darin speichern
        Vector<Seat> allSeats = this.seatMapper.findAll();
        // Vector erzeugen, in den über die nachfolgende for-Schleife die Ids aller Sitzstrukturen gespeichert werden
        Vector<String> allSeatInformations = new Vector<String>();
            // Standardwert für Vector definieren
            allSeatInformations.add("Bitte auswählen");

        for(int i = 0; i<allSeats.size(); i++) {
            // Id der aktuellen Sitzstruktur auslesen und in Stringvariable speichern
            String seatInformation = "Sitzstruktur " + allSeats.get(i).getSeatId() + ", Gesamtsitzplatzanzahl: " + allSeats.get(i).getNumberOfAllSeats() +
                                     " Sitzplätze, verteilt auf " + allSeats.get(i).getNumberOfRows() + " Reihen mit je "
                                     + allSeats.get(i).getSeatsPerRow() + " Sitzplätzen";
            // Stringvariable in Vector speichern
            allSeatInformations.add(seatInformation);
        }

        return allSeatInformations;
    }

    /**
     * Gibt alle Buchungen für die JTable aus
     *
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllBookingsForTable() throws java.rmi.RemoteException {

        // Vector erzeugen und alle Buchungen aus der Datenbank hineinspeichern
        Vector<Booking> allBookings = this.bookingMapper.findAll();
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();
        
        // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
        for(int i = 0; i<allBookings.size(); i++) {

            // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Buchungs-Objekte zwischengespeichert werden
            Vector<String> TempString = new Vector<String>();

                // Buchungsnummer der aktuellen Buchung auslesen
                String bookingId = String.valueOf(allBookings.get(i).getBookingId());
                    TempString.add(bookingId);
                // Flugnummer der aktuellen Buchung auslesen
                String realizationId = String.valueOf(allBookings.get(i).getRealizationId());
                    TempString.add(realizationId);
                // Namen des Passagiers der aktuellen Buchung auslesen
                int passengerId = allBookings.get(i).getPassengerId();
                    TempString.add(String.valueOf(passengerId));
                    
                    Passenger p = this.passengerMapper.findById(passengerId);
                        String firstName = p.getFirstName();
                        String lastName = p.getLastName();
                            String passengerName = lastName + ", " + firstName;
                                TempString.add(passengerName);
                // Check-in-Datum der aktuellen Buchung auslesen
                Date checkInDate = allBookings.get(i).getCheckInDate();
                    String checkInDateAsString = String.valueOf(r.convertDateToStringWithoutWeekday(checkInDate));
                // Sitzplatz der aktuellen Buchung auslesen
                String seatPosition = allBookings.get(i).getSeatPosition();
                
                // Überprüfen ob der Passagier der aktuellen Buchung bereits eingecheckt hat
                if(seatPosition.equals("")) {
                    // Wenn nicht werden zwei entsprechende Meldungen in der Tabelle angezeigt
                    String default1 = "Noch nicht eingecheckt";
                        TempString.add(default1);
                    String default2 = "Noch kein Sitzplatz";
                        TempString.add(default2);
                }
                else {
                    // Wenn doch, werden das Check-in-Datum sowie der Sitzplatz angezeigt
                    TempString.add(checkInDateAsString);
                    TempString.add(seatPosition);
                }

            /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
             * wird dieser in den Vector mit den Daten für die JTable gespeichert */
            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Buchungen einer Flugdurchführung (FlightRealization) für die JTable aus
     *
     * @param realizationId (Nr. der Flugdurchführung)
     * @return Vector<Vector>
     * @throws java.rmi.RemoteException
     */
    public Vector<Vector> getAllBookingsByRealizationIdForTable(int realizationId) throws java.rmi.RemoteException {

        // Vector erzeugen und alle Buchungen der ausgewählten Flugdurchführung aus der Datenbank hineinspeichern
        Vector<Booking> allBookingsByRealizationId = this.bookingMapper.findAllByRealizationId(realizationId);
        // Vector mit nachfolgender for-Schleife mit Werten für JTable belegen
        Vector<Vector> tableData = new Vector<Vector>();

        // Report-Objekt erzeugen um Date-Objekte umzuwandeln
        Report r = new Report();

        // For-Schleife schreibt alle Objekte aus der Datenbank in den Vector für die JTable
        for(int i = 0; i<allBookingsByRealizationId.size(); i++) {

            // Zunächst wird ein temporärer Vector angelegt in den die Daten der einzelnen Buchungs-Objekte zwischengespeichert werden
            Vector<String> TempString = new Vector<String>();

                // Buchungsnummer der aktuellen Buchung auslesen
                String bookingId = String.valueOf(allBookingsByRealizationId.get(i).getBookingId());
                    TempString.add(bookingId);
                // Flugnummer der aktuellen Buchung auslesen
                String realizationIdAsString = String.valueOf(allBookingsByRealizationId.get(i).getRealizationId());
                    TempString.add(realizationIdAsString);
                // Namen des Passagiers der aktuellen Buchung auslesen
                int passengerId = allBookingsByRealizationId.get(i).getPassengerId();
                    TempString.add(String.valueOf(passengerId));

                    Passenger p = this.passengerMapper.findById(passengerId);
                        String firstName = p.getFirstName();
                        String lastName = p.getLastName();
                            String passengerName = lastName + ", " + firstName;
                                TempString.add(passengerName);
                // Check-in-Datum der aktuellen Buchung auslesen
                Date checkInDate = allBookingsByRealizationId.get(i).getCheckInDate();
                    String checkInDateAsString = String.valueOf(r.convertDateToStringWithoutWeekday(checkInDate));
                // Sitzplatz der aktuellen Buchung auslesen
                String seatPosition = allBookingsByRealizationId.get(i).getSeatPosition();

                // Überprüfen ob der Passagier der aktuellen Buchung bereits eingecheckt hat
                if(seatPosition.equals("")) {
                    // Wenn nicht werden zwei entsprechende Meldungen in der Tabelle angezeigt
                    String default1 = "Noch nicht eingecheckt";
                        TempString.add(default1);
                    String default2 = "Noch kein Sitzplatz";
                        TempString.add(default2);
                }
                else {
                    // Wenn doch, werden das Check-in-Datum sowie der Sitzplatz angezeigt
                    TempString.add(checkInDateAsString);
                    TempString.add(seatPosition);
                }

            /* Sind alle Informationen ausgelesen und in den temporären Vector gespeichert,
             * wird dieser in den Vector mit den Daten für die JTable gespeichert */
            tableData.addElement(TempString);
        }

        return tableData;
    }

    /**
     * Gibt alle Passagiere aus, die eingecheckt haben
     *
     * @return vector<Booking>
     * @throws java.rmi.RemoteException
     */
    public Vector<Booking> findAllBookingsByAlreadyCheckedIn() throws java.rmi.RemoteException {

        return this.bookingMapper.findAllByAlreadyCheckedIn();
    }

    /**
     * Gibt alle Flugzeuge für die ComboBox zurück die im entsprechenden Zeitraum zur Verfügung stehen.
     *
     * @param dateOfDeparture
     * @param dateOfArrival
     * @param airlineId
     * @return Vector<Aircraft> mit allen verfügbaren Flugzeugen
     * @throws java.rmi.RemoteException
     */
    public Vector<Aircraft> getAllAircraftsByAvailabilityForComboBox(Date dateOfDeparture, Date dateOfArrival, int airlineId)
            throws java.rmi.RemoteException {

        // Vector erzeugen und alle Flugzeuge, die im ausgewählten Zeitraum zur Verfügung stehen darin speichern
        Vector<Aircraft> allAvailableAircraftsForComboBox =
                this.aircraftMapper.findAircraftsByAvailability(dateOfDeparture, dateOfArrival, airlineId);

        return allAvailableAircraftsForComboBox;
    }


    /*      -       getBy-Methoden     -       */


    /**
     * Gibt den Flughafen anhand des Namens zurück
     * @param portName
     * @return Einen Flughafen
     * @throws java.rmi.RemoteException
     */
    public Airport getAirportByName(String portName) throws java.rmi.RemoteException {

        return this.airportMapper.findByName(portName);
    }

    /**
     * Gibt den Flughafen anhand der Id zurück
     * @param id
     * @return Einen Flughafen
     * @throws java.rmi.RemoteException
     */
    public Airport getAirportById(String id) throws java.rmi.RemoteException {

        return this.airportMapper.findByInternationalId(id);
    }

    /**
     * Gibt die Fluglinie anhand des Namens zurück
     * @param name
     * @return Eine Fluglinie
     * @throws java.rmi.RemoteException
     */
    public Airline getAirlineByName(String name) throws java.rmi.RemoteException {

        return this.airlineMapper.findByName(name);
    }

    /**
     * Gibt die Fluglinie anhand der Id zurück
     * @param id
     * @return Eine Fluglinie
     * @throws java.rmi.RemoteException
     */
    public Airline getAirlineById(int id) throws java.rmi.RemoteException {

        return this.airlineMapper.findById(id);
    }

    /**
     * Gibt ein Flugzeug anhand des Namens zurück
     * @param name
     * @return Ein Flugzeug
     * @throws java.rmi.RemoteException
     */
    public Aircraft getAircraftByName(String name) throws java.rmi.RemoteException {

        return this.aircraftMapper.findByName(name);
    }

    /**
     * Gibt ein Flugzeug anhand der Id zurück
     * @param id
     * @return Ein Flugzeug
     * @throws java.rmi.RemoteException
     */
    public Aircraft getAircraftById(int id) throws java.rmi.RemoteException {

        return this.aircraftMapper.findById(id);
    }

    /**
     * Gibt einen Flugzeugtyp anhand des Namens zurück
     * @param type
     * @return Ein Flugzeugtyp
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft getTypeOfAircraftByName(String type) throws java.rmi.RemoteException {

        return this.typeOfAircraftMapper.findByName(type);
    }

    /**
     * Gibt ein Flugzeug anhand der Id zurück
     * @param id
     * @return
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft getTypeOfAircraftById(int id) throws java.rmi.RemoteException {

        return this.typeOfAircraftMapper.findById(id);
    }

    /**
     * Gibt einen Flug anhand der Id zurück
     * @param id
     * @return Ein Flug
     * @throws java.rmi.RemoteException
     */
    public Flight getFlightById(int id) throws java.rmi.RemoteException {

        return this.flightMapper.findById(id);
    }

    /**
     * Gibt eine Flugdurchführung anhand der Id zurück
     * @param id
     * @return Eine Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public FlightRealization getFlightRealizationById(int id) throws java.rmi.RemoteException {

        return this.flightRealizationMapper.findById(id);
    }

    /**
     * Gibt einen Passagier anhand der Id zurück
     * @param id
     * @return Ein Passagier
     * @throws java.rmi.RemoteException
     */
    public Passenger getPassengerById(int id) throws java.rmi.RemoteException {

        return this.passengerMapper.findById(id);
    }

    /**
     * Gibt einen Passagier anhand des Namens zurück
     * @param firstName
     * @param lastName
     * @return Ein Passagier
     * @throws java.rmi.RemoteException
     */
    public Vector<Passenger> getPassengerByName(String firstName, String lastName) throws java.rmi.RemoteException {

        return this.passengerMapper.findByName(firstName, lastName);
    }

    /**
     * Gibt eine Sitzstruktor anhand der Id zurück
     *
     * @param id (Id der Sitzstruktur)
     * @return Seat-Objekt
     * @throws java.rmi.RemoteException
     */
    public Seat getSeatById(int id) throws java.rmi.RemoteException {

        return this.seatMapper.findById(id);
    }

    /**
     * Gibt eine bestimmte Buchung zurück
     * @param id
     * @return Eine bestimmte Buchung bei der Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public Booking getBookingById(int id) throws java.rmi.RemoteException {

        return this.bookingMapper.findById(id);
    }

    /**
     * Gibt eine bestimmte Buchung zurück
     * @param id
     * @return Eine bestimmte Buchung bei der Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public Booking getBookingByRealizationId(int id) throws java.rmi.RemoteException {

        return this.bookingMapper.findByRealizationId(id);
    }

    /**
     * Gibt die Referenz eines ReportGenerators zurück
     * 
     * @return reportGenerator
     * @throws RemoteException
     */
    public ReportGenerator getReportGenerator() throws java.rmi.RemoteException {

        return this.reportGenerator;
    }

    /**
     * Buchungen pro Passagier anhand der Airline und der Zeit finden
     * @param passengerId
     * @param airlineId
     * @param startDate
     * @param endDate
     * @return Eine bestimmte Buchung
     * @throws java.rmi.RemoteException
     */
    public Vector<Booking> findBookingsByPassengerByAirlineAndByTimeframe(int passengerId, int airlineId, Date startDate, Date endDate) throws java.rmi.RemoteException {

        //Vector, der alle Flüge einer Airline festhält
        Vector<Flight> allFlightsOfAirline = this.flightMapper.findAllFlightsAssociatedWithAirline(airlineId);
        //Vector, der alle FlightRealizations festhält, die auf den oben gefundenen Flügen basieren (von einer bestimmten Airline)
        Vector<FlightRealization> allFlightRealizationsForFlights = new Vector<FlightRealization>();
        // Vector, der alle FlightRealizations im gewünschten Zeitraum enthält
        Vector<FlightRealization> allFlightRealisationsInTimeframe = this.flightRealizationMapper.findAllFlightRealizationsByTimeframe(startDate, endDate);
        // Vector, der alle FlightRealization-Ids der FlightRealizations im gewünschten Zeitraum für einen Abgleich enthält
        Vector<Integer> allFRidsInTimeframe = new Vector<Integer>();
        //Vector, der alle FlightRealizations festhält, die einer bestimmten Airline bzw. Flug UND in dem gewünschten Zeitraum durchgeführt werden
        Vector<FlightRealization> allFlightROfAirlineAndTimeframe = new Vector<FlightRealization>();
        //Vector, der alle Buchungen aller FlightRealizations festhält, die mit einer bestimmten Airline in einem bestimmten Zeitraum durchgeführt werden
        Vector<Booking> allBookingsWithDesiredAirlineAndTimeframeAndPassengerId = new Vector<Booking>();


        for(int i = 0; i<allFlightsOfAirline.size(); i++){

            Vector<FlightRealization> allFlightRForSpecificFlight = this.flightRealizationMapper.findAllFlightRAssociatedWithFlightId(allFlightsOfAirline.get(i).getFlightId());

            allFlightRealizationsForFlights.addAll(allFlightRForSpecificFlight);
        }

            for(int i = 0; i<allFlightRealisationsInTimeframe.size(); i++) {

                    int realizationId = allFlightRealisationsInTimeframe.get(i).getRealizationId();
                    allFRidsInTimeframe.add(realizationId);
            }
        
                for(int i = 0; i<allFlightRealizationsForFlights.size(); i++){

                    int realizationId = allFlightRealizationsForFlights.get(i).getRealizationId();

                    if(allFRidsInTimeframe.contains(realizationId)) {
                        allFlightROfAirlineAndTimeframe.addElement(allFlightRealizationsForFlights.get(i));
                    }
                    else {

                    }
                }

                    for(int i = 0; i<allFlightROfAirlineAndTimeframe.size();i++){

                        Vector<Booking> allDesiredBookings = this.bookingMapper.findAllByRealizationIdAndPassengerId(allFlightROfAirlineAndTimeframe.get(i).getRealizationId(), passengerId);

                        allBookingsWithDesiredAirlineAndTimeframeAndPassengerId.addAll(allDesiredBookings);

                    }

        return allBookingsWithDesiredAirlineAndTimeframeAndPassengerId;

    }

    /**
     * Anzahl der Buchungen für eine Flugdurchführung
     *
     * @param realizationId, Nr. der Flugdurchführung
     * @return Integerwert mit der Anzahl der Buchungen für eine bestimmte Flugdurchführung
     * @throws java.rmi.RemoteException
     */
    public int findNumberOfBookingsForRealizationId(int realizationId) throws java.rmi.RemoteException {

        return this.bookingMapper.findNumberOfBookingsForRealizationId(realizationId);
    }

    /**
     * Gibt die Gesamtsitzplatzanzahl der ausgewählten FlightRealization zurück
     *
     * @param realizationId (Nr. der Flugdurchführung
     * @return numberOfAllSeats (Gesamtsitzplatzanzahl)
     * @throws java.rmi.RemoteException
     */
    public int findNumberOfAllSeatsForRealizationId(int realizationId) throws java.rmi.RemoteException {

        return this.flightRealizationMapper.getNumberOfAllSeats(realizationId);
    }

    /**
     * Check-In für eine bestimmte Buchung durchführen
     * @param b
     * @return Check-In
     * @throws java.rmi.RemoteException
     */
    public boolean executeCheckInForSpecificBooking(Booking b) throws java.rmi.RemoteException {

        return this.bookingMapper.executeCheckInForSpecificBooking(b);
    }


    /*      -       SetCurrentObject-Methoden     -       */

    /**
     * Aktuell ausgewähltes Aircraft-Objekt wird in Variable zwischengespeichert
     *
     * @param currentAircraft (Aktuelles Flugzeugobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentAircraft(Aircraft currentAircraft) throws java.rmi.RemoteException {

        this.currentAircraft = currentAircraft;
    }

    /**
     * Aktuell ausgewähltes Airline-Objekt wird in Variable zwischengespeichert
     *
     * @param currentAirline (Aktuelles Fluglinienobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentAirline(Airline currentAirline) throws java.rmi.RemoteException {

        this.currentAirline = currentAirline;
    }

    /**
     * Aktuell ausgewähltes Airport-Objekt wird in Variable zwischengespeichert
     *
     * @param currentAirport (Aktuelles Flughafenobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentAirport(Airport currentAirport) throws java.rmi.RemoteException {

        this.currentAirport = currentAirport;
    }

    /**
     * Aktuell ausgewähltes Booking-Objekt wird in Variable zwischengespeichert
     *
     * @param currentBooking (Aktuelles Buchungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentBooking(Booking currentBooking) throws java.rmi.RemoteException {

        this.currentBooking = currentBooking;
    }

    /**
     * Aktuell ausgewähltes Flight-Objekt wird in Variable zwischengespeichert
     *
     * @param currentFlight (Aktuelles Flugobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentFlight(Flight currentFlight) throws java.rmi.RemoteException {

        this.currentFlight = currentFlight;
    }

    /**
     * Aktuell ausgewähltes FlightRealization-Objekt wird in Variable zwischengespeichert
     *
     * @param currentFlightRealization (Aktuelles Flugdurchführungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentFlightRealization(FlightRealization currentFlightRealization) throws java.rmi.RemoteException {

        this.currentFlightRealization = currentFlightRealization;
    }

    /**
     * Aktuell ausgewähltes Passenger-Objekt wird in Variable zwischengespeichert
     *
     * @param currentPassenger (Aktuelles Passagierobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentPassenger(Passenger currentPassenger) throws java.rmi.RemoteException {

        this.currentPassenger = currentPassenger;
    }

    /**
     * Aktuell ausgewähltes Seat-Objekt wird in Variable zwischengespeichert
     *
     * @param currentSeat (Aktuelles Sitzstrukturobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentSeat(Seat currentSeat) throws java.rmi.RemoteException {

        this.currentSeat = currentSeat;
    }

    /**
     * Aktuell ausgewähltes TypeOfAircraft-Objekt wird in Variable zwischengespeichert
     *
     * @param currentTypeOfAircraft (Aktuelles Flugzeugtypobjekt)
     * @throws java.rmi.RemoteException
     */
    public void setCurrentTypeOfAircraft(TypeOfAircraft currentTypeOfAircraft) throws java.rmi.RemoteException {

        this.currentTypeOfAircraft = currentTypeOfAircraft;
    }


    /*      -       GetCurrentObject-Methoden     -       */

    /**
     * Gibt das aktuelle Aircraft-Objekt zurück
     * 
     * @return currentAircraft (Aktuelles Flugzeugobjekt)
     * @throws java.rmi.RemoteException
     */
    public Aircraft getCurrentAircraft() throws java.rmi.RemoteException {

        return this.currentAircraft;
    }

    /**
     * Gibt das aktuelle Airline-Objekt zurück
     *
     * @return currentAirline (Aktuelles Fluglinienobjekt)
     * @throws java.rmi.RemoteException
     */
    public Airline getCurrentAirline() throws java.rmi.RemoteException {

        return this.currentAirline;
    }

    /**
     * Gibt das aktuelle Airport-Objekt zurück
     *
     * @return currentAirport (Aktuelles Flughafenobjekt)
     * @throws java.rmi.RemoteException
     */
    public Airport getCurrentAirport() throws java.rmi.RemoteException {

        return this.currentAirport;
    }

    /**
     * Gibt das aktuelle Booking-Objekt zurück
     *
     * @return currentBooking (Aktuelles Buchungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public Booking getCurrentBooking() throws java.rmi.RemoteException {

        return this.currentBooking;
    }

    /**
     * Gibt das aktuelle Flight-Objekt zurück
     * 
     * @return currentFlight (Aktuelles Flugobjekt)
     * @throws java.rmi.RemoteException
     */
    public Flight getCurrentFlight() throws java.rmi.RemoteException {

        return this.currentFlight;
    }

    /**
     * Gibt das aktuelle FlightRealization-Objekt zurück
     *
     * @return currentFlightRealization (Aktuelles Flugdurchführungsobjekt)
     * @throws java.rmi.RemoteException
     */
    public FlightRealization getCurrentFlightRealization() throws java.rmi.RemoteException {

        return this.currentFlightRealization;
    }

    /**
     * Gibt das aktuelle Passenger-Objekt zurück
     *
     * @return currentPassenger (Aktuelles Passagierobjekt)
     * @throws java.rmi.RemoteException
     */
    public Passenger getCurrentPassenger() throws java.rmi.RemoteException {

        return this.currentPassenger;
    }

    /**
     * Gibt das aktuelle Seat-Objekt zurück
     *
     * @return currentSeat (Aktuelles Sitzstrukturobjekt)
     * @throws java.rmi.RemoteException
     */
    public Seat getCurrentSeat() throws java.rmi.RemoteException {

        return this.currentSeat;
    }

    /**
     * Gibt das aktuelle TypeOfAircraft-Objekt zurück
     *
     * @return currentTypeOfAircraft (Aktuelles Flugzeugtypobjekt)
     * @throws java.rmi.RemoteException
     */
    public TypeOfAircraft getCurrentTypeOfAircraft() throws java.rmi.RemoteException {

        return this.currentTypeOfAircraft;
    }
    
}

 